How to Use Akema: The Beginner's Guide (First Connect, CEL Traps, and In-Browser DuckDB Analytics)

CodexFuse Team · 2026-11-03T15:48:45.880Z · 12 min read min read

How to Use Akema: The Beginner's Guide (First Connect, CEL Traps, and In-Browser DuckDB Analytics)

Learning how to use Akema takes an afternoon, not a sprint: it is a read-only Kafka message inspector that lets you connect to a cluster, see live messages with their keys, headers, offsets, and decoded payloads, trap the interesting ones with CEL expressions, and run SQL over the message window with DuckDB in your browser. If you have ever written a throwaway consumer just to look at one payload — a chore Akema's own site pegs at 30 to 90 minutes of scripting, credentials, and deserialization — Akema replaces that loop with a browser tab, so you can inspect a Kafka topic without writing a consumer, and that is the product's whole pitch. This Akema tutorial walks the full beginner arc: installing the single binary (or Docker), connecting to your first cluster, writing your first CEL trap, and querying the live window with SQL. New to the underlying technology first? Start with our what Apache Kafka is explainer, then come back. Note the sibling lane once: Akema is a debugging lens, while our WarpStream beginner guide covers a Kafka-protocol streaming platform and our RisingWave beginner guide covers a streaming SQL database — different functions, never rivals.

What Is Akema, Exactly?

Akema is a read-only lens on the window you need: browse live messages, trap the ones that matter with CEL, and chart them with DuckDB in your browser. Nothing is written back to Kafka. That one sentence — straight from the akema.io homepage — is the whole product thesis: instead of writing a throwaway consumer script every time you need to eyeball a topic, you point Akema at your bootstrap servers and get the key, headers, offset, partition, timestamp, and decoded body the moment you connect.

Akema is not an admin console. Its own FAQ is explicit: it does not manage ACLs, connectors, or broker config, and it is not a streaming SQL engine or a producer tool. It is the inspection layer a team leaves open — the thing developers, QA, operations, data, and platform engineers all open instead of maintaining five scripts and three UIs.

What Does Akema Show You the Moment You Connect?

Connecting shows you the full anatomy of each record immediately — no deserialization code on your side, and that is what makes the Akema Kafka inspector different from a plain viewer. Every message arrives with the following fields visible in the live table.

JSON payloads decode automatically. Avro and Protobuf decode to readable JSON when you supply a Schema Registry connection or upload the matching schema files — without a schema source, binary Avro stays unreadable, which is the single most common beginner confusion and is covered in the mistakes table below.

What Akema Deliberately Does Not Do to Your Cluster

Akema is read-only by design, and that is the line that gets it through change control: produce is off and republish is not in the product, it uses its own consumer group and never commits offsets for your application groups, it makes no admin-API calls that mutate topics or ACLs, payload rings live in memory so a restart drops messages, and there is no vendor telemetry. Targeted reads use assign-and-seek rather than group joins, so your application groups never rebalance because of it. Say that to your platform team once and the security review gets much shorter.

How Do You Install Akema?

You install Akema as one binary with no database, agent, or JVM to set up — it works with KRaft and needs no ZooKeeper. Linux (amd64 and arm64) and Docker are the fully supported platforms; the macOS and Windows builds are still marked beta and unsigned. Version 1.0.0 is the current release, verified from the docs' download file names on 2026-11-03.

Linux install, exactly as the official install docs show:

curl -L -O "$AKEMA_DOWNLOADS/akema_1.0.0_linux_amd64.tar.gz"
sha256sum -c SHA256SUMS
tar -xzf akema_1.0.0_linux_amd64.tar.gz
sudo install -m 0755 akema /usr/local/bin/akema

# one binary, loopback only
./akema -addr 127.0.0.1:8080

Linux needs glibc 2.28 or newer (Ubuntu 20.04, Debian 11, RHEL 8 and up all qualify). Prefer containers? The docs give the Docker route with a named data volume and a data-directory environment variable — our Docker beginner guide covers the underlying mechanics if you are new to it:

docker run --rm -p 127.0.0.1:8080:8080 \
  -v akema-data:/data \
  -e AKEMA_DATA_DIR=/data \
  "$AKEMA_IMAGE:1.0.0"

The docs express the image as a placeholder variable, so fetch the current image reference from akema.io before you pull — the download page itself was returning 404 at write time, so do not guess the registry path. Open http://127.0.0.1:8080 in your browser and you are on the welcome screen.

How Do You Connect to Your First Cluster?

Connecting is a five-step arc that takes minutes: start the binary, open the loopback address, add a source, paste your bootstrap servers, and pick your topics. Follow these steps in order.

1. Start Akema on loopback. Run the binary with -addr 127.0.0.1:8080 and open that address in your browser. Bind to localhost until you know why you need more.
2. Add a source. Sources are your named connections — "prod-orders", "staging-events" — each one holding its own topics, traps, and workspace.
3. Paste bootstrap servers and pick topics. Run the binary next to your brokers, enter the bootstrap list, and select the topics you want to watch. TLS, mTLS, SASL, and Schema Registry sit in the same connection matrix.
4. Choose your seek position. Start from latest, earliest, the last N messages, an exact offset, or a timestamp — the offset/timestamp seeks use the Kafka protocol directly.
5. Watch the live table fill. Key, headers, offset, partition, timestamp, and decoded body stream in as messages arrive.

Supported backends are self-managed Kafka (KRaft, no ZooKeeper needed), Amazon MSK, Azure Event Hubs' Kafka API, and Confluent Cloud. For sampling-heavy topics, Akema can sample every Nth message, cap reads, or read a single offset band — handy when a firehose topic would otherwise flood the window.

How Do Akema CEL Traps Catch the Bad Messages for You?

A trap is a rule Akema checks against every message as it arrives: a short, safe CEL expression that returns true or false. CEL is Google's Common Expression Language (the docs link to cel.dev), and Akema uses standard CEL — the optional CEL extensions are not available, so write to the core language. Every trap sees the same set of variables.

The docs' primary example finds expensive failed payments, and the homepage shows the same pattern on checkout events:

value_json.status == "payment_failed" && value_json.total_usd > 1000

value_json.event_type in ["add_to_cart", "purchase"] && value_json.user_id == null

The traps doc adds ready-made recipes for the rest of the arc:

value_json.status in ["payment_failed", "refunded"]
value_json.total_usd >= 1000 && value_json.total_usd < 5000
headers["source"] == "checkout"
value_json.order_id.matches("^ORD-[0-9]{6}$")
timestamp > timestamp("2026-10-20T14:00:00Z")
partition == 3 && offset > 120000
has(value_json.coupon)

Trap hits get marked under the topic's offset rail in the stream navigator, so a day of traffic collapses into a handful of flagged moments. Write one trap per failure mode — "failed payments over $1,000", "checkouts with no user id" — rather than one monster expression, and they become a living test suite for your event stream.

How Does the In-Browser DuckDB Analytics Work?

Arrow batches load the current message window into DuckDB running inside your browser, where you can query it in SQL or drag inferred fields onto the canvas. The default Explore canvas loads the 10,000 most recent messages per source — enough to chart a spike, count event types, or find the partition with the skewed traffic. When the session ends, the topic data is dropped; there is nothing to clean up and nothing persisted.

A typical first query over the loaded window looks like this:

SELECT value_json.event_type AS event, COUNT(*) AS n
FROM messages
GROUP BY 1
ORDER BY n DESC;

Drag a field onto the canvas and the chart appears without the SQL; write the SQL when you want exact control. This is analytics over the window you are looking at, not a warehouse — the moment you close the session, the data is gone.

What Is Present Mode (and the Display Covers)?

Present mode turns your traps and charts into a locked, full-screen story for the ops-room screen: press Present and the card chrome hides while the charts pick up the active display cover's palette. The seven covers — Light, Paper, Metamorphosis, Trial, Castle, Ink, and Night — take their cues from mid-century Kafka jackets, so the big screen looks deliberate instead of like a developer's tab. Leave it on the wall during an incident and everyone watches the same traps.

Which Akema Plan Do You Actually Need?

Pricing is per-node commercial licensing, not open source: a 14-day offline trial ships with everything in Solo, no sign-up and no telemetry, and after that you pick one of two lanes. The license arrives by email as a file bound to the machine, works air-gapped, runs to the end of the paid year plus 14 days' grace, and imports with one command:

akema -license-import ./akema.license

Start on Replay if you are learning or replaying captured fixtures; move to Solo when you need a live cluster. The Team plan is currently "Next" on the roadmap — team licensing, an MCP server for AI assistants (still read-only), and gated republish — with no price announced yet. Checkout runs through Link with Stripe as the merchant of record.

What Are the 5 Beginner Mistakes With Akema?

Every first-week stumble with Akema traces back to one of these five. The table names each one and the fix.

Sources

• Akema homepage — https://akema.io (fetched live 2026-11-03): product definition, read-only guarantees, connect flow, per-message fields, supported backends, present mode, display covers, pricing, 30–90-minute throwaway-consumer claim.
• Akema docs — install page, https://akema.io/docs/install/ (fetched live 2026-11-03): Linux tarball + SHA256SUMS, Docker run shape, platform support (Linux/Docker full, macOS/Windows beta), version 1.0.0, no ZooKeeper/JVM/database.
• Akema docs — traps page, https://akema.io/docs/traps/ (fetched live 2026-11-03): trap definition, standard-CEL rule with optional extensions unavailable, the variable table, all example expressions and recipes.
• Akema Product Hunt listing — https://www.producthunt.com/products/akema (published 2026-11-02, updated 2026-11-03): launch confirmation, maker Jason Young, 1.0 platform notes, $99/node/year pricing confirmation.

Frequently Asked Questions

Is Akema really read-only?

Yes. Produce is off, republish is not in the product, it makes no admin-API calls that mutate topics or ACLs, payload rings live in memory, and there is no vendor telemetry. It connects with its own consumer group and never commits offsets for your application groups.

Does Akema need ZooKeeper, a JVM, or a database?

No. It ships as one binary, works with KRaft, and offset/timestamp seeks use the Kafka protocol directly — the docs are explicit that there is no database, agent, or JVM to set up.

What does a CEL trap look like?

A short, safe formula returning true or false, written in standard Google CEL: value_json.status == "payment_failed" && value_json.total_usd > 1000 flags expensive failed payments. Traps see value_json, value, key, headers, topic, partition, offset, and timestamp.

Is Akema free or paid?

Both exist: the Replay plan is $0 forever for fixtures, the live table, traps, Explore, and Present; Solo is $99 per node/year for live Kafka with TLS/mTLS/SASL, Avro/Protobuf, and up to 32 workspaces. A 14-day offline trial includes everything in Solo with no sign-up.

Is Akema open source?

No. It is proprietary commercial software licensed per node — the license arrives as a file bound to the machine and imports with akema -license-import. No open-source license or public repo was found at write time.