Kick off your book project, get started with GhostAI, get better at marketing, or spend the day doing all three! Free live workshops on Zoom. Saturday, June 27, 2026.

Leanpub Header

Skip to main content
Go to Leanpub.com

Building AI Agents with C# and .NET 10

A Developer’s First Guide to the Microsoft Agent Framework

Rachid DAHIR

Build production AI agents in C# and .NET 10 with the Microsoft Agent Framework — from your first ChatClientAgent to multi-agent systems, multimodal vision, and a hosted, observable, safety-filtered production app. Nineteen chapters and 60+ runnable projects, all on the stable MAF 1.11 release. Written for developers who'd rather build than read another blog post

Minimum price

$29.99

$49.99

You pay

Author earns

$

Also available for 2 book credits with a Reader Membership

PDF
About

About

About the Book

Every .NET team is being asked the same question: can we put a real agent in this? Building AI Agents with C# and .NET 10 is the end-to-end answer — written in C#, for developers who would rather build than stitch together a dozen blog posts.

The Microsoft Agent Framework (MAF) is Microsoft's unified, production-minded SDK for AI agents — the consolidation of Semantic Kernel and AutoGen into one stack. This is the developer's first guide to it, built entirely on the stable MAF 1.11 release and .NET 10 / C# 14.

You'll create your first ChatClientAgent, give it a persona and durable memory, then hand it real power: tools through AIFunctionFactory, the Model Context Protocol, retrieval-augmented generation, and multimodal vision. From there you'll orchestrate multi-agent workflows — sequential pipelines, hub-and-spoke specialists, group chat, and human-in-the-loop approval. Part V takes you to production: ASP.NET Core + .NET Aspire hosting, OpenTelemetry observability, a five-layer safety pipeline, agent skills, and evaluation. By the final chapter you'll have built the Contoso FAQ agent — a small but real production system — and earned the intuition to ship your own.

Nineteen chapters, five parts, and 60+ runnable companion projects. Every concept is anchored in working code, and every API targets the stable MAF 1.11 surface — no preview ceremony, no abandoned snippets. Migrating from Semantic Kernel or AutoGen? The appendices map your old patterns straight onto the new ones.

For C# developers who want to build production agents, not demos.

Share this book

Categories

C#Agentic EngineeringArtificial IntelligenceLarge language modelsMicrosoft Agent Framework

Feedback

Email the Author

Author

About the Author

Rachid DAHIR

I design systems for the long haul.

As a software architect, technical author, and educator based in Morocco, I've spent more than a decade building enterprise-grade .NET solutions in financial services, healthcare, and large-scale enterprise environments — where reliability, performance, and clean architecture are not optional.

I write for developers who are ready to move past tutorials. My books share a deliberate standard: production-grade code only — no toy examples, no shortcuts that would never survive a code review; every concept explained, demonstrated, then practiced; every advanced topic taught with the same patience as an introductory one — because complexity is never an excuse for a poor explanation.

Whether you're a mid-career developer leveling up, a solution architect consolidating best practices, or an enterprise team standardizing modern .NET, my goal stays the same: clarity without compromise.

When I'm not writing code or prose, I explore mathematics, AI research, and natural health.

Contents

Table of Contents

Building AI Agents with C# and .NET 10 — Table of Contents

Building AI Agents with C# and .NET 10

A Developer’s First Guide to the Microsoft Agent Framework

Front Matter

  • Preface
  • Introduction
  • About the Author

Part I — Foundations

  1. The AI Revolution in .NET
    • From software you write to software you delegate to
    • What makes software agentic: the agent loop
    • Agents, workflows, and plain LLM calls
    • Where .NET sits in the AI world
    • How Semantic Kernel and AutoGen became the Microsoft Agent Framework
    • Where agents fit in your career
    • Three things that change when the model joins your stack
    • Agents act — and that changes the risk picture
    • What you’ll build in this book
    • A first glimpse of the code
    • A word on how this book treats you
    • When not to reach for an agent
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  2. C# Essentials for AI Development
    • Async, Task, and CancellationToken
    • Records, primary constructors, and required members
    • Raw string literals
    • Pattern matching for LLM response dispatch
    • Collection expressions, nullable references, and extension methods
    • JSON serialization with System.Text.Json
    • Dependency injection and Minimal API
    • What this earns you in the rest of the book
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  3. How LLMs Work: A Developer’s Mental Model
    • Tokens — the atom of the LLM world
    • The conversation is a list of messages
    • Next-token prediction — the mechanism
    • Temperature and top-p — controlling randomness
    • Prompting techniques — just enough for Chapter 5
    • Embeddings and cosine similarity
    • Token economics — what this costs
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  4. Setting Up Your Dev Environment
    • Install the SDK and IDE
    • Pick a provider
    • Provisioning
    • Configure appsettings.json
    • Your first LLM call
    • Your first streaming response
    • When the first call fails
    • Summary
    • Practice Exercises
    • What’s Next

Part II — Your First Agents

  1. Hello, Agent!
    • What a ChatClientAgent actually is
    • Three ways to create an agent
    • Sessions are optional
    • Non-streaming: RunAsync
    • Overriding options per call
    • When the call fails
    • Streaming: RunStreamingAsync
    • Exposing the agent over HTTP
    • Putting it together — the mental model
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  2. Conversations and Memory
    • The amnesia problem
    • Sessions and history providers
    • Where does the conversation actually live?
    • Persisting sessions across restarts
    • Context providers
    • Keeping history under the window
    • Short-term vs long-term memory
    • Putting it all together
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  3. Structured Output and Typed Responses
    • Why typed responses matter
    • Your first typed call
    • Records, JSON attributes, schemas
    • Enums as structured validators
    • Not every agent supports structured output
    • The other door: ResponseFormat
    • Typed output while streaming
    • Tightening the schema (strict mode)
    • A production-grade typed call
    • Validating the extraction
    • When typed responses fail
    • The cost of a schema
    • Structured output under trimming and AOT
    • Polymorphic and discriminated-union responses
    • When to reach for typed responses
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next

Part III — Giving Agents Superpowers

  1. Tools and Function Calling
    • The tool landscape
    • The tool-calling loop
    • Your first tool
    • Multiple tools and chaining
    • Inside the loop — FunctionInvokingChatClient and its limits
    • Controlling tool choice
    • The shell tool — the most dangerous tool you’ll build
    • Tools backed by dependency injection
    • Concurrent tool calls
    • Graceful degradation
    • Tool approval — keeping a human in the loop
    • Giving an agent its own files: FileAccessProvider
    • Testing your tools
    • Tool design principles
    • Integrating with Chapter 7 — typed tools
    • Putting it together — the agent grows up
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  2. The Model Context Protocol
    • What MCP is (and isn't)
    • Building an MCP server in C#
    • MCP transports — stdio, SSE, HTTP
    • Consuming an MCP server from an agent
    • The capability-negotiation handshake
    • Cross-language interop
    • A second MCP server — knowledge base preview
    • When to use MCP (and when not to)
    • Debugging an MCP server
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  3. Introduction to RAG
    • What RAG is
    • Embeddings, revisited in code
    • The RAG pipeline
    • Chunking strategies
    • The Contoso FAQ agent — wiring RAG into an agent
    • One provider, two modes: always-on vs on-demand
    • Metadata filtering
    • RAG-specific security
    • The cost of getting RAG wrong
    • Evaluating RAG quality
    • Hosted RAG — when MAF does the heavy lifting
    • When RAG is the wrong tool
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  4. Multimodal Agents
    • The same agent, a richer message
    • Two ways to send an image: URL and bytes
    • Choosing a vision model
    • From a picture to a typed C# record
    • An image is not free
    • An image is untrusted input
    • Multimodal RAG, honestly
    • Audio: two real paths
    • Video: sample the frames
    • Testing multimodal agents without a model
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next

Part IV — Multi-Agent Collaboration

  1. Multi-Agent Systems
    • When to reach for multi-agent
    • Sequential pipeline — the simplest case
    • The orchestrator-and-specialists pattern
    • Agents-as-tools — the mental model
    • Content pipeline — Researcher → Writer → Editor
    • The built-in orchestrations
    • Streaming through a pipeline
    • Every inter-agent boundary is a trust boundary
    • Testing multi-agent compositions
    • The pattern catalog
    • BuildSequential vs manual chaining
    • Observability, cost, and failure modes
    • Mixing models, and the growing context
    • Design principles for multi-agent
    • When NOT to go multi-agent
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  2. Introduction to Workflows
    • Why workflows
    • The primitives
    • Sequential workflow
    • Conditional edges — branching on data
    • Agents as workflow executors
    • Approval workflow — human-in-the-loop with a revision loop
    • Checkpointing and durable resume
    • State isolation — fresh instance per run
    • Idiomatic fan-out and fan-in
    • Sub-workflows and workflows-as-agents
    • Visualizing a workflow
    • Testing workflows
    • The workflow event stream
    • Workflows vs multi-agent — when to pick which
    • Design principles
    • When workflows are the wrong tool
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next

Part V — Going to Production

  1. Hosting and Deployment
    • Why hosting matters
    • AddAIAgent() — the hosting extension
    • Streaming from a hosted agent
    • .NET Aspire — orchestration and observability in one
    • The A2A protocol — agent discovery and invocation over HTTP
    • Securing the agent API
    • Rate limiting and resilience
    • Deployment considerations
    • Containerizing the agent service
    • Deploying to the cloud
    • A fully-hosted Contoso FAQ agent
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  2. Observability and Debugging
    • The three pillars
    • OpenTelemetry — the .NET story
    • The GenAI semantic conventions
    • Structured logging with ILogger
    • Custom metrics
    • Custom traces with ActivitySource
    • Running it
    • Exporting to production
    • Dashboards worth building
    • When observability fails you
    • Evaluation: the fourth signal
    • Debugging an agent in production
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  3. Safety and Guardrails
    • The Quality Pyramid
    • A threat model to anchor the layers — OWASP LLM Top 10
    • Middleware — DelegatingChatClient and .Use()
    • Input sanitization — prompt injection and PII
    • The critic-agent pattern
    • Injecting safety context mid-run — the AIContextProvider hook
    • Indirect prompt injection — when the attack hides in the data
    • Excessive Agency — gating the tools that can act
    • Improper Output Handling — the answer is untrusted input
    • Unbounded Consumption — denial-of-wallet and runaway loops
    • Graduating from regex — Azure AI Content Safety
    • Closing the loop — logging hygiene and retention
    • Combining the layers
    • Design principles for safety
    • When safety fails
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  4. Agent Skills
    • What a Skill is, and what it is not
    • Progressive disclosure — the four stages
    • Providing skills to an agent — the AgentSkillsProvider
    • Code-defined skills — AgentInlineSkill
    • Class-based skills — AgentClassSkill<T>
    • Mixing skill sources — AgentSkillsProviderBuilder
    • Watching progressive disclosure run
    • Gating scripts with human approval
    • Customising the system prompt
    • Dependency injection through skills
    • Security — treating skills like dependencies
    • Skills vs. workflows — when to pick which
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  5. Evaluation
    • Why eval is the blind spot of agent dev
    • The three core types
    • LocalEvaluator and the built-in EvalChecks
    • Custom checks with FunctionEvaluator.Create
    • EvaluateAsync — running queries against an evaluator
    • FoundryEvals — cloud-based LLM-as-judge scoring
    • Conversation split strategies
    • Mixing local and cloud evaluators in one pass
    • Evaluating workflows — Run.EvaluateAsync and per-agent breakdown
    • Evaluating a RAG agent: grounding the Contoso FAQ agent
    • The judge client: ChatConfiguration
    • Safety evaluation
    • Eval-driven development
    • Composing with Microsoft.Extensions.AI.Evaluation
    • Wiring eval into CI
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  6. Your Next Steps
    • What to build next
    • The agentic protocol triad: A2A and AG-UI
    • Enterprise governance patterns
    • Contributing to MAF
    • Where the ecosystem is heading
    • Staying current
    • A short send-off
    • Summary
    • Key Terms
    • What’s Next After This Book

Appendices

  • Appendix A — NuGet Package Reference
  • Appendix B — Semantic Kernel to MAF Migration Map
  • Appendix C — AutoGen to MAF Migration Map
  • Appendix D — Glossary
  • Appendix E — Exercise Solutions Reference
  • Keyword Index
Building AI Agents with C# and .NET 10 — Table of Contents

Building AI Agents with C# and .NET 10

A Developer’s First Guide to the Microsoft Agent Framework

Front Matter

  • Preface
  • Introduction
  • About the Author

Part I — Foundations

  1. The AI Revolution in .NET
    • From software you write to software you delegate to
    • What makes software agentic: the agent loop
    • Agents, workflows, and plain LLM calls
    • Where .NET sits in the AI world
    • How Semantic Kernel and AutoGen became the Microsoft Agent Framework
    • Where agents fit in your career
    • Three things that change when the model joins your stack
    • Agents act — and that changes the risk picture
    • What you’ll build in this book
    • A first glimpse of the code
    • A word on how this book treats you
    • When not to reach for an agent
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  2. C# Essentials for AI Development
    • Async, Task, and CancellationToken
    • Records, primary constructors, and required members
    • Raw string literals
    • Pattern matching for LLM response dispatch
    • Collection expressions, nullable references, and extension methods
    • JSON serialization with System.Text.Json
    • Dependency injection and Minimal API
    • What this earns you in the rest of the book
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  3. How LLMs Work: A Developer’s Mental Model
    • Tokens — the atom of the LLM world
    • The conversation is a list of messages
    • Next-token prediction — the mechanism
    • Temperature and top-p — controlling randomness
    • Prompting techniques — just enough for Chapter 5
    • Embeddings and cosine similarity
    • Token economics — what this costs
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  4. Setting Up Your Dev Environment
    • Install the SDK and IDE
    • Pick a provider
    • Provisioning
    • Configure appsettings.json
    • Your first LLM call
    • Your first streaming response
    • When the first call fails
    • Summary
    • Practice Exercises
    • What’s Next

Part II — Your First Agents

  1. Hello, Agent!
    • What a ChatClientAgent actually is
    • Three ways to create an agent
    • Sessions are optional
    • Non-streaming: RunAsync
    • Overriding options per call
    • When the call fails
    • Streaming: RunStreamingAsync
    • Exposing the agent over HTTP
    • Putting it together — the mental model
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  2. Conversations and Memory
    • The amnesia problem
    • Sessions and history providers
    • Where does the conversation actually live?
    • Persisting sessions across restarts
    • Context providers
    • Keeping history under the window
    • Short-term vs long-term memory
    • Putting it all together
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  3. Structured Output and Typed Responses
    • Why typed responses matter
    • Your first typed call
    • Records, JSON attributes, schemas
    • Enums as structured validators
    • Not every agent supports structured output
    • The other door: ResponseFormat
    • Typed output while streaming
    • Tightening the schema (strict mode)
    • A production-grade typed call
    • Validating the extraction
    • When typed responses fail
    • The cost of a schema
    • Structured output under trimming and AOT
    • Polymorphic and discriminated-union responses
    • When to reach for typed responses
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next

Part III — Giving Agents Superpowers

  1. Tools and Function Calling
    • The tool landscape
    • The tool-calling loop
    • Your first tool
    • Multiple tools and chaining
    • Inside the loop — FunctionInvokingChatClient and its limits
    • Controlling tool choice
    • The shell tool — the most dangerous tool you’ll build
    • Tools backed by dependency injection
    • Concurrent tool calls
    • Graceful degradation
    • Tool approval — keeping a human in the loop
    • Giving an agent its own files: FileAccessProvider
    • Testing your tools
    • Tool design principles
    • Integrating with Chapter 7 — typed tools
    • Putting it together — the agent grows up
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  2. The Model Context Protocol
    • What MCP is (and isn't)
    • Building an MCP server in C#
    • MCP transports — stdio, SSE, HTTP
    • Consuming an MCP server from an agent
    • The capability-negotiation handshake
    • Cross-language interop
    • A second MCP server — knowledge base preview
    • When to use MCP (and when not to)
    • Debugging an MCP server
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  3. Introduction to RAG
    • What RAG is
    • Embeddings, revisited in code
    • The RAG pipeline
    • Chunking strategies
    • The Contoso FAQ agent — wiring RAG into an agent
    • One provider, two modes: always-on vs on-demand
    • Metadata filtering
    • RAG-specific security
    • The cost of getting RAG wrong
    • Evaluating RAG quality
    • Hosted RAG — when MAF does the heavy lifting
    • When RAG is the wrong tool
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  4. Multimodal Agents
    • The same agent, a richer message
    • Two ways to send an image: URL and bytes
    • Choosing a vision model
    • From a picture to a typed C# record
    • An image is not free
    • An image is untrusted input
    • Multimodal RAG, honestly
    • Audio: two real paths
    • Video: sample the frames
    • Testing multimodal agents without a model
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next

Part IV — Multi-Agent Collaboration

  1. Multi-Agent Systems
    • When to reach for multi-agent
    • Sequential pipeline — the simplest case
    • The orchestrator-and-specialists pattern
    • Agents-as-tools — the mental model
    • Content pipeline — Researcher → Writer → Editor
    • The built-in orchestrations
    • Streaming through a pipeline
    • Every inter-agent boundary is a trust boundary
    • Testing multi-agent compositions
    • The pattern catalog
    • BuildSequential vs manual chaining
    • Observability, cost, and failure modes
    • Mixing models, and the growing context
    • Design principles for multi-agent
    • When NOT to go multi-agent
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  2. Introduction to Workflows
    • Why workflows
    • The primitives
    • Sequential workflow
    • Conditional edges — branching on data
    • Agents as workflow executors
    • Approval workflow — human-in-the-loop with a revision loop
    • Checkpointing and durable resume
    • State isolation — fresh instance per run
    • Idiomatic fan-out and fan-in
    • Sub-workflows and workflows-as-agents
    • Visualizing a workflow
    • Testing workflows
    • The workflow event stream
    • Workflows vs multi-agent — when to pick which
    • Design principles
    • When workflows are the wrong tool
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next

Part V — Going to Production

  1. Hosting and Deployment
    • Why hosting matters
    • AddAIAgent() — the hosting extension
    • Streaming from a hosted agent
    • .NET Aspire — orchestration and observability in one
    • The A2A protocol — agent discovery and invocation over HTTP
    • Securing the agent API
    • Rate limiting and resilience
    • Deployment considerations
    • Containerizing the agent service
    • Deploying to the cloud
    • A fully-hosted Contoso FAQ agent
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  2. Observability and Debugging
    • The three pillars
    • OpenTelemetry — the .NET story
    • The GenAI semantic conventions
    • Structured logging with ILogger
    • Custom metrics
    • Custom traces with ActivitySource
    • Running it
    • Exporting to production
    • Dashboards worth building
    • When observability fails you
    • Evaluation: the fourth signal
    • Debugging an agent in production
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  3. Safety and Guardrails
    • The Quality Pyramid
    • A threat model to anchor the layers — OWASP LLM Top 10
    • Middleware — DelegatingChatClient and .Use()
    • Input sanitization — prompt injection and PII
    • The critic-agent pattern
    • Injecting safety context mid-run — the AIContextProvider hook
    • Indirect prompt injection — when the attack hides in the data
    • Excessive Agency — gating the tools that can act
    • Improper Output Handling — the answer is untrusted input
    • Unbounded Consumption — denial-of-wallet and runaway loops
    • Graduating from regex — Azure AI Content Safety
    • Closing the loop — logging hygiene and retention
    • Combining the layers
    • Design principles for safety
    • When safety fails
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  4. Agent Skills
    • What a Skill is, and what it is not
    • Progressive disclosure — the four stages
    • Providing skills to an agent — the AgentSkillsProvider
    • Code-defined skills — AgentInlineSkill
    • Class-based skills — AgentClassSkill<T>
    • Mixing skill sources — AgentSkillsProviderBuilder
    • Watching progressive disclosure run
    • Gating scripts with human approval
    • Customising the system prompt
    • Dependency injection through skills
    • Security — treating skills like dependencies
    • Skills vs. workflows — when to pick which
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  5. Evaluation
    • Why eval is the blind spot of agent dev
    • The three core types
    • LocalEvaluator and the built-in EvalChecks
    • Custom checks with FunctionEvaluator.Create
    • EvaluateAsync — running queries against an evaluator
    • FoundryEvals — cloud-based LLM-as-judge scoring
    • Conversation split strategies
    • Mixing local and cloud evaluators in one pass
    • Evaluating workflows — Run.EvaluateAsync and per-agent breakdown
    • Evaluating a RAG agent: grounding the Contoso FAQ agent
    • The judge client: ChatConfiguration
    • Safety evaluation
    • Eval-driven development
    • Composing with Microsoft.Extensions.AI.Evaluation
    • Wiring eval into CI
    • Summary
    • Key Terms
    • Practice Exercises
    • What’s Next
  6. Your Next Steps
    • What to build next
    • The agentic protocol triad: A2A and AG-UI
    • Enterprise governance patterns
    • Contributing to MAF
    • Where the ecosystem is heading
    • Staying current
    • A short send-off
    • Summary
    • Key Terms
    • What’s Next After This Book

Appendices

  • Appendix A — NuGet Package Reference
  • Appendix B — Semantic Kernel to MAF Migration Map
  • Appendix C — AutoGen to MAF Migration Map
  • Appendix D — Glossary
  • Appendix E — Exercise Solutions Reference
  • Keyword Index

Get the free sample chapters

Click the buttons to get the free sample in PDF or EPUB, or read the sample online here

Download Sample PDF

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

See full terms...

Earn $8 on a $10 Purchase, and $16 on a $20 Purchase

We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

In fact, authors have earned over $15 million writing, publishing and selling on Leanpub.

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub