Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
AI Agents in Action

AI Agents in Action

Build, orchestrate, and deploy autonomous multi-agent systems
Give language models tools, memory, and limits, then test whether their actions deserve trust.
by Micheal Lanham 2025 344 pages
3.10
78 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat autonomy as a dial, not a label for every AI assistant

Four levels of agency. The book distinguishes direct conversation with a language model from a proxy that reformulates requests, an assistant that can call tools with approval, and an autonomous agent that plans and acts independently. A weather lookup can be a single tool call; sorting email and notifying the user requires the system to judge importance and act on that judgment. These categories matter because they assign different levels of authority, not just different names.

Build only as much autonomy as needed. Agents can also divide work among specialized profiles, such as a coder and a tester coordinated by a controller. The more independence the system receives, the more its goals, tools, checks, and permission boundaries need careful design.

Analysis

The useful distinction is not whether a system sounds intelligent, but what it is allowed to do without asking. This resembles access control in ordinary software: reading data, proposing a change, and committing the change are separate privileges. That framing makes the book's broad use of “agent” practical, while also preventing the term from obscuring meaningful differences. A low-autonomy assistant can be safer and more predictable than a supposedly sophisticated autonomous system. The design question becomes concrete: which decisions can be delegated, and which require confirmation?

Choose a model and prompt for the task's constraints, not prestige

Fit beats fame. The book recommends weighing task performance, model size, intended use, training domain, context capacity, speed, and cost. A coding agent needs a model that handles code well; a private workflow may favor a locally hosted model. LM Studio offers a way to test local models and check whether available hardware can run them. Commercial models can be easier to start with, but bring cost and external data handling.

Make requests legible. Clear prompts can specify role, relevant context, delimiters, steps, examples, and output format. Temperature adjusts response variability, while token use affects cost and speed. Short, focused replies can also reduce noise when agents communicate. The right combination should be tested on the actual task, not inferred from model size alone.

Analysis

This is a decision problem with several competing objectives, much like engineering a database or choosing a deployment platform. A single “best model” ranking cannot settle questions of latency, privacy, budget, or domain fit. The book's practical emphasis on trying models locally and refining prompts is therefore stronger than a hunt for a universal winner. One useful extension is to test against a small set of representative cases, including awkward inputs and failure conditions. Otherwise, a prompt can look excellent on a showcase example and break on the first ordinary variation.

Define tools narrowly, because a function call is only a proposal

Models select, software executes. When an LLM receives a function definition, it can identify a matching function and supply parameters, but it does not run that function itself. The surrounding application must validate the arguments, call the implementation, and return the result to the model. This separation is essential: an apparent tool call is a request for action, not evidence that the action happened.

Keep interfaces useful. The book shows how a service can expose ordinary API functions as natural-language tools. In its movie example, returning only titles limited the model's ability to apply a user's follow-up criteria. Returning structured movie data gave it more material to filter. Tool descriptions and parameters should be clear, and each agent should receive only the abilities its job requires.

Analysis

This separation creates a valuable safety seam. The language model interprets intent, while deterministic code can validate inputs, enforce limits, and record what happened. That division mirrors the distinction between a user interface and a trusted service layer. Rich results can help an LLM reason over data, but more information also means more exposure and more tokens, so “return everything” is not always wise. A robust tool contract should provide enough context to answer the task while withholding fields the agent has no reason to see.

Add agents only when distinct roles improve results enough to justify their cost

Specialists can check one another. AutoGen supports proxy conversations, nested exchanges, and shared group chats. A proxy can ask a coding assistant to write code, run it, and return feedback. CrewAI instead organizes role-based agents around explicit tasks, either in sequence or under a manager. The book's examples include a joke researcher and writer, plus a coding team with engineers and reviewers.

Coordination has a bill. More conversation means more tokens, latency, and chances to repeat work. In one observed joke-generation run, the book reports a cost a little above fifty cents. A hierarchical coding crew cost more than twice as much as its simpler version without a clearly better result. AgentOps helps inspect calls, timing, repetition, and estimated expense.

Analysis

A team structure is useful only if its members contribute different evidence or capabilities. When several agents share the same model and assumptions, their agreement may be correlated rather than independent confirmation. A critic role can still improve work, especially when paired with executable tests, but role names alone do not create expertise. The strongest case for multi-agent design is division of labor with observable handoffs. Before adding another conversational worker, compare the system against a simpler workflow and ask whether the extra coordination changes measurable outcomes.

Put a behavior tree between an agent's goal and its actions

Control the route to completion. A behavior tree is a hierarchy of nodes that runs from top to bottom and left to right. A sequence requires each step to succeed; a selector tries alternatives until one succeeds. Condition nodes test whether a requirement holds, while action nodes perform work. This structure, used in robotics and games, can organize agent tasks without burying every decision in one prompt.

Agentic behavior trees apply this control to assistants. In the book's coding challenge, one assistant drafts a solution, another judges it by running tests, and a verifier checks the result. The tree can stop on failure or continue through a defined fallback. Back chaining helps design the tree by starting with the goal, then identifying necessary actions, conditions, and communication paths.

Analysis

Behavior trees bring a familiar software virtue to probabilistic systems: explicit control flow. A visible tree makes it easier to locate which condition failed, which action ran, and where a fallback should occur. That is a meaningful improvement over an opaque prompt that asks an agent to “handle everything.” The complication is that an LLM-backed node may return uncertain or inconsistent results. Conditions therefore need operational definitions, such as a passing test or a validated file, rather than accepting a confident-sounding response as success.

Retrieve relevant memories instead of stuffing entire documents into prompts

RAG supplies selected context. Retrieval-augmented generation, or RAG, indexes documents by splitting them into chunks, converting chunks into embeddings, and storing them for similarity search. A query is embedded too; matching passages are retrieved and supplied to the model as context. This can support questions about a book or script without repeatedly sending the entire source. The book contrasts simple TF-IDF, which emphasizes word frequency, with embeddings designed to represent meaning.

Memory uses a related pipeline. Conversation facts or preferences can be extracted, stored, and retrieved when relevant. The book distinguishes semantic memory for facts, episodic memory for events, and procedural memory for processes. Chunk size and overlap affect retrieval. Clustering and summarization can compress repetitive stores, though compression may discard details that a later question needs.

Analysis

RAG is not simply “add a vector database.” Its quality depends on what is indexed, how it is divided, what the search retrieves, and whether the answer stays grounded in those sources. That makes retrieval a data-design problem as much as a model problem. Memory adds a governance issue: storing a preference can make future interactions more useful, but users should be able to understand and correct what is retained. Compression trades storage and retrieval efficiency for possible loss of nuance, so the uncompressed source should remain available when accuracy matters.

Measure prompt quality against a rubric before trusting a polished answer

Replace prompt intuition with comparison. Prompt flow lets developers run prompt or profile variations, including batches of different inputs, and inspect outputs and usage. The book's recommender example evaluates suggestions against criteria such as subject, format, and genre, using a rating scale from poor to excellent alignment. A separate evaluation prompt scores the generated recommendations, and Python code aggregates results across runs.

Grounding makes expectations explicit. In this context, grounding means checking whether a response follows the rubric, task, and context. The book compares prompt variants that place recommendation inputs in different parts of the prompt and finds better results when those inputs are placed in the system instructions. A repeatable rubric makes that comparison more useful than simply preferring the answer that sounds best.

Analysis

Rubrics turn vague quality judgments into inspectable criteria, a practice shared with education, human-computer interaction, and software testing. They also expose disagreements about what “good” means. An LLM evaluator can scale comparisons, but it can inherit the same blind spots as the generator and may reward fluent answers that satisfy a weak rubric. Human review and reference cases remain important, especially when errors carry consequences. Evaluation is most informative when it tests not only typical requests, but also edge cases and conflicting instructions.

Treat step-by-step reasoning as a method to test, not proof of correctness

Prompting can elicit reasoning-shaped work. The book explores direct question answering, few-shot examples, zero-shot classification, chain-of-thought prompts, and prompt chaining. Self-consistency generates several answers and selects the most similar; Tree of Thought explores and evaluates multiple solution paths. These methods can make intermediate work visible and help structure difficult tasks, but none guarantees a correct conclusion.

The time-travel puzzle exposes the gap. Alex arrives before a ten-day battle, spends six days there, jumps forward fifty years for twenty days, then returns to witness the battle's end. Different prompts produce different totals, and the wording leaves ambiguity about where in time he returns. The book's Tree of Thought example may make up to 27 model calls, with some branches rejected and others still wrong.

Analysis

A detailed explanation can make an answer easier to audit, but it is not itself evidence that the answer is true. The puzzle is useful precisely because the timeline invites hidden assumptions, and a system can reason consistently from an assumption the question never established. Similarity voting can also select a popular error when generations share the same bias. For consequential work, intermediate reasoning should be paired with independent checks: arithmetic, executable tests, source citations, or explicit clarification of ambiguous premises.

Plan dependent actions in sequence, then inspect and constrain execution

Parallel calls are not a plan. A basic LLM can often request several independent tool calls, but a task where later actions depend on earlier results needs sequential planning. In the book's Wikipedia example, an agent without a planner can search but may not reliably continue to download pages and save them. An OpenAI assistant can carry out the dependent steps. A simple planner can also ask an LLM for a JSON plan using only available functions, then execute those functions locally.

Feedback and safeguards still matter. Planning can reduce tool chatter, but the planner may misunderstand a goal or produce a bad step. The book's advanced model gives a reasoned but incorrect answer to the time-travel puzzle, then generates corrective guidance when told the expected answer. Limit available tools, use isolated execution for generated code, and require checks or human approval for consequential actions.

Analysis

A plan is an intention, not a transaction guarantee. Reliable systems need to consider what happens when a step fails halfway through, is retried, or changes something irreversible. This connects agent design to distributed systems, where explicit state, validation, and safe retries prevent small faults from becoming larger ones. The book's warning about agents using tools in unintended ways makes least privilege and sandboxing practical necessities, not decorative precautions. Feedback can improve behavior, but it should not substitute for external checks when the expected result can be verified directly.

Analysis

Lanham's book is best understood as an applied engineering tour, not a claim that autonomous intelligence has been solved. Its narrative begins with a long-running ambition to build useful intelligent systems, then follows the sudden accessibility created by conversational language models. The practical destination is not one magic framework. It is a collection of interacting design choices: a model, profile, tools, retrieval, control flow, evaluation, planning, and feedback.

The most durable contribution is the insistence that an agent is a system around a language model. A model may interpret a request, but application code determines which tools exist, what data they expose, whether actions execute, and how results are checked. This boundary clarifies both capability and responsibility. It also explains why autonomy should be incremental: a system that can read, suggest, and request approval is materially different from one that can edit files, call APIs, or publish content.

The book's tutorial format makes abstract distinctions tangible through working examples, from a CSV analyst to a movie service, coding teams, retrieval stores, and behavior-tree workflows. That breadth is useful for orientation, though it creates a tension: frameworks and provider features change faster than the architectural questions they illustrate. Readers should treat named platforms as examples, and preserve the deeper lessons about interfaces, control, and verification.

The central caution is that visible sophistication can be mistaken for reliability. More agents, longer reasoning traces, or elaborate plans may consume resources without improving outcomes. The text repeatedly supplies counterexamples: repeated agent thoughts, expensive crews, wrong puzzle solutions, and tool behavior that requires isolation. The sound engineering response is experimental discipline: define a measurable goal, restrict permissions, instrument cost and behavior, test failure cases, and prefer direct verification over persuasive prose. That stance makes the book valuable to developers who want useful agents without confusing autonomy with trustworthiness.

Summary in 30 Seconds
Reliable AI applications depend on boundaries around the language model: narrow tools, validate arguments, isolate generated code, and require approval for consequential actions. Choose models by task, cost, speed, and privacy. Retrieve relevant passages rather than whole documents. Coordinate specialists only when quality gains justify latency and expense. Evaluate outputs with explicit rubrics, because branching reasoning and elaborate plans can remain wrong.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.10 out of 5
Average of 78 ratings from Goodreads and Amazon.

AI Agents in Action receives mixed reviews, with ratings ranging from 1 to 5 stars. Some readers praise its practical focus and comprehensive coverage of AI agent development, while others criticize its reliance on third-party tools and lack of depth. Positive reviews highlight the book's value for learning to build AI agents, especially using OpenAI capabilities. Negative reviews mention outdated content, overreliance on code snippets, and insufficient explanation of core concepts. Several readers note the rapid pace of change in the field, making parts of the book quickly obsolete.

Your rating:
3.98
239 ratings
Want to read the full book?

Glossary

Agentic behavior trees (ABTs)

Trees that control agents

Agentic behavior trees apply behavior-tree control flow to assistants or agents. Their nodes use prompts to perform actions or test conditions, while sequence and selector logic determines what happens next. They can coordinate separate assistants, tools, files, and conversation threads, providing explicit structure for completing a goal and checking whether a step succeeded.

Behavior trees

Hierarchical action control

A behavior tree organizes an AI system's actions and conditions into a hierarchy. A sequence proceeds through children until one fails, while a selector tries children until one succeeds. Action nodes do work, condition nodes report success or failure, and other node types can control or parallelize execution. The pattern is used in robotics and game AI.

Retrieval augmented generation (RAG)

Generation with retrieved context

RAG retrieves relevant material from an external store and adds it to a language model's prompt. Documents are commonly split into chunks, embedded as vectors, and stored for similarity search. A user's query is also embedded, and matching passages are supplied as context. The pattern supports document question answering and provides a foundation for agent knowledge and memory.

Semantic memory

Meaning-focused memory retrieval

In the book's usage, semantic memory processing interprets incoming information and extracts questions or concepts relevant to a memory store before retrieval. This extra step aims to make recall more relevant than simple similarity matching. The term can describe the processing method, while semantic, episodic, and procedural identify different kinds of remembered content.

Grounding

Scoring against stated criteria

Grounding evaluates whether a model response aligns with a prompt's context, instructions, objectives, and rubric. A rubric defines criteria and performance levels, such as a rating scale for how well a recommendation matches requested subject, format, and genre. Grounding can be assessed manually or with another model, and supports systematic comparison of prompt variations.

Self-consistency

Selecting among generated answers

Self-consistency generates multiple candidate answers to the same problem, then compares them and selects the answer judged most representative or similar to the others. It can reduce reliance on one generation, especially when the model's output varies. Agreement is not proof of correctness, since candidates may share assumptions or repeat the same error.

Tree of thought (ToT)

Exploration of alternative reasoning paths

Tree of Thought prompting explores multiple candidate plans or reasoning paths, evaluates them, and continues with paths that pass the evaluation. It can be organized breadth-first, considering alternatives at each level, or depth-first, following one path farther before branching. The approach can help examine complex problems, but may require many model calls and still return incorrect results.

Prompt flow

Prompt testing and evaluation

Prompt flow is Microsoft's tool for constructing workflows from model calls and code blocks, testing prompt variations, and evaluating results in batches. A flow can pass inputs through prompts, embedding steps, parsers, and evaluation logic. The book uses it to compare agent profiles with rubrics and inspect outputs, model usage, and run metrics.

FAQ

What is AI Agents in Action by Micheal Lanham about?

  • Comprehensive guide to AI agents: The book explores how to build, orchestrate, and deploy autonomous multi-agent systems using large language models (LLMs) and behavior trees.
  • Focus on practical implementation: It covers foundational concepts, hands-on examples, and advanced techniques for creating intelligent agents.
  • Bridges theory and practice: Readers learn both the theoretical underpinnings and practical skills needed to develop agentic AI systems.

Why should I read AI Agents in Action by Micheal Lanham?

  • Bridges theory and real-world skills: The book not only explains agent theory but also provides practical code examples, exercises, and demonstrations.
  • Covers state-of-the-art tools: It introduces platforms like OpenAI Assistants API, AutoGen, CrewAI, and Microsoft’s Prompt Flow, preparing readers for current and future AI development.
  • Focus on autonomy: Emphasizes creating agents that can plan, reason, evaluate, and learn from feedback, moving beyond simple chatbots.

What are the key takeaways from AI Agents in Action by Micheal Lanham?

  • Holistic agent design: Readers gain a deep understanding of agent components—profiles, actions, memory, planning, reasoning, evaluation, and feedback.
  • Hands-on with modern frameworks: The book teaches how to use tools like GPT Assistants Playground, Nexus, LangChain, Semantic Kernel, and Prompt Flow.
  • Future-ready skills: It prepares readers to build autonomous, multi-agent systems capable of complex workflows and decision-making.

Who is Micheal Lanham, the author of AI Agents in Action?

  • Experienced innovator: Micheal Lanham is a software innovator with over two decades of experience in AI, machine learning, and software development.
  • Diverse expertise: His background spans gaming, graphics, AI agents, and reinforcement learning.
  • Educator and practitioner: Lanham’s writing bridges the gap between academic theory and practical application for developers and researchers.

What are the core components of an AI agent as described in AI Agents in Action?

  • Agent profiles and personas: Define the agent’s personality, role, and behavior through system prompts and instructions.
  • Actions and tools: Agents use both native (code-based) and semantic (prompt-based) functions to perform tasks, which can be dynamically discovered and executed.
  • Memory and knowledge: Agents maintain both short-term and long-term memory, using retrieval augmented generation (RAG) to access relevant information.
  • Planning, reasoning, evaluation, and feedback: These enable agents to break down goals, reason through problems, evaluate solutions, and adapt based on feedback.

How does AI Agents in Action by Micheal Lanham define and use agent profiles and personas?

  • Profile and persona basics: An agent’s profile describes its role, function, and background, often defined in a system prompt called a persona.
  • Creation methods: Profiles can be handcrafted, generated by LLMs, or created using data-driven techniques like evolutionary algorithms.
  • Importance for behavior: Well-crafted personas help agents respond contextually and consistently, enhancing their effectiveness in specialized tasks.

What is prompt engineering and how is it taught in AI Agents in Action by Micheal Lanham?

  • Prompt engineering defined: The practice of crafting detailed, clear, and structured prompts to improve LLM output quality and consistency.
  • Strategies and tactics: The book covers writing detailed queries, adopting personas, using delimiters, specifying steps, providing examples, and controlling output length.
  • Systematic evaluation: Readers learn to use tools like Microsoft’s Prompt Flow for iterative prompt design, testing, and rubric-based evaluation.

How does AI Agents in Action by Micheal Lanham explain memory and knowledge in AI agents?

  • Memory vs. knowledge: Memory stores agent interactions and preferences, while knowledge refers to external documents or facts used to augment prompts.
  • Retrieval augmented generation (RAG): Both memory and knowledge use RAG, embedding text into vectors for semantic similarity search and prompt augmentation.
  • Memory compression: The book discusses clustering and summarizing memories/knowledge to reduce redundancy and improve retrieval efficiency.

What are behavior trees and how are they applied in AI Agents in Action by Micheal Lanham?

  • Behavior tree basics: Hierarchical control structures used in robotics and games to manage complex decision-making through nodes like selectors, sequences, conditions, and actions.
  • Agentic behavior trees (ABTs): The book adapts behavior trees to AI agents, using prompts to direct actions and conditions for autonomous multi-agent control.
  • Practical examples: Readers build ABTs for tasks like coding challenges, social media posting, and autonomous task orchestration.

How does AI Agents in Action by Micheal Lanham approach reasoning, planning, and feedback in AI agents?

  • Reasoning techniques: Covers direct solution prompting, few-shot/zero-shot prompting, Chain of Thought (CoT), and Tree of Thought (ToT) for step-by-step reasoning.
  • Planning mechanisms: Shows how agents break down goals into sequential or parallel tasks using prompt engineering and planners that generate executable plans.
  • Feedback integration: Demonstrates feedback loops where agents learn from errors and refine future plans, using both automated and human-in-the-loop assessments.

What practical tools and platforms does AI Agents in Action by Micheal Lanham teach for building AI agents?

  • Nexus platform: An open-source agent platform built with Streamlit, supporting agent profiles, actions, memory, and planning.
  • GPT Assistants Playground: A Gradio-based interface for creating and managing autonomous assistants using behavior trees and custom actions.
  • LangChain and Semantic Kernel: Frameworks for building retrieval augmented generation workflows and integrating external knowledge.
  • Prompt Flow: A Microsoft tool for systematic prompt development, testing, and evaluation.

What are the best quotes from AI Agents in Action by Micheal Lanham and what do they mean?

  • “Behavior trees are a robust and scalable AI control pattern…” — Highlights the modularity and flexibility of behavior trees for autonomous agent control.
  • “Back chaining is a method for constructing behavior trees by working backward from the goal behavior.” — Emphasizes goal-driven design in agent behavior construction.
  • “Memory and knowledge compression are techniques for condensing information stored in memory and knowledge systems…” — Reflects the importance of efficient information management in AI agents.
  • “Prompt engineering is an iterative process… Test Changes Systematically is such a core facet…” — Underlines the necessity of systematic evaluation and iteration in prompt design.
  • “Planning is central to agents and assistants, allowing them to take a goal, break it into steps, and execute them.” — Reinforces planning as the key to moving from simple chatbots to autonomous agents.

About the Author

Micheal Lanham is the author of "AI Agents in Action," a book focused on the design and implementation of autonomous AI agents. Lanham's work explores various tools and frameworks for building AI agents, including OpenAI's capabilities, GPT Nexus, LangChain, and CrewAI. His approach emphasizes practical applications and hands-on learning, providing readers with code examples and detailed explanations of agent-building techniques. Lanham demonstrates expertise in areas such as planning, multi-agent systems, and memory management for AI agents. His writing style is noted for its technical accuracy and clarity, though some readers find the content structure challenging. Lanham's work reflects the rapidly evolving nature of AI technology and its applications.

Download PDF

To save this AI Agents in Action summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.39 MB     Pages: 20

Download EPUB

To read this AI Agents in Action summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.37 MB     Pages: 25
Want to read the full book?
Follow
Listen16 mins
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 25,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...