---
title: "The backend your coding agent stops rebuilding"
description: "Media, models, embeddings, and routes are one Python file. Claude Code, Cursor, and Codex reach a working app with less code, less glue, and fewer wrong turns."
url: "https://www.pixeltable.com/agents"
---

# The backend your coding agent stops rebuilding

Media, models, embeddings, and routes are one Python file. Claude Code, Cursor, and Codex reach a working app with less code, less glue, and fewer wrong turns.

Install the skill: `npx skills add pixeltable/pixeltable-skill`. Or let the agent run `pxt new`: one hosted database, no account. Claim it within 48 hours. Setup playbook: https://www.pixeltable.com/get-started.md

## Same app, two backends

From https://github.com/pixeltable/showcase-call-intelligence, abridged. The Celery task:

```python
@celery_app.task(name="worker.tasks.process_call", ...)
def process_call(call_id: str) -> None:
    db = SessionLocal()
    try:
        call = db.get(Call, uuid.UUID(call_id))
        call.status = "transcribing"
        db.commit()

        diarized = transcribe_diarize(call.audio_path)
        labeled = extract_segments(diarized)
        for pos, seg in enumerate(labeled):
            db.add(TranscriptSegment(call_id=call.id, pos=pos, ...))

        client = OllamaClient()
        result = client.enrich_call(transcript_text, ...)
        call.summary = result.summary
        # ... action items, sentiment, category, QA scorecard

        embed_call_segments(db, call.id)
        call.status = "completed"
        db.commit()
    except Exception as exc:
        db.rollback()
        call.status = "failed"
        call.error_message = str(exc)
```

The Pixeltable schema for the same product:

```python
class Calls(TableModel, name="calls"):
    uuid = pxt.Column(type=pxt.UUID, primary_key=True)
    audio: pxt.Audio | None
    video: pxt.Video | None
    vertical: pxt.String | None
    # ...
    diarized = pxt.Column(value=transcribe(audio=source_audio, ...))
    segments = functions.extract_segments(diarized)
    transcript_text = functions.flatten_transcript_segments(segments)

    summary_raw = chat(model=config.OLLAMA_MODEL, ...)["message"]["content"]
    summary = functions.parse_summary_content(transcript_text, summary_raw)
    # ... action items, sentiment, category, QA scorecard


class TranscriptSegments(
    TableModel,
    name="transcript_segments",
    base=Calls.where(Calls.segments != None),
    iterator=list_iterator(Calls.segments),
):
    __indexes__ = [
        pxt.EmbeddingIndex(text, embedding=embed_fn, name="segments_embed")
    ]
```

1. **A queue and a worker.** A Celery task, Redis, and a process to run it. Pixeltable: Insert a row into the table. Its columns run.
2. **Media as a file path.** The recording is a path in a string column. Pixeltable: `pxt.Audio` is a column type that models and iterators read directly.
3. **A row loop into a second table.** Segments are copied out one `db.add` at a time. Pixeltable: A view with `list_iterator` makes one row per segment.
4. **A model call inside the task.** The prompt runs once, inside one function. Pixeltable: Each model call is a column; a prompt change recomputes it.
5. **Embeddings synced by hand.** A helper writes vectors, and a repair task fills the gaps. Pixeltable: The index is declared on the column and kept current.
6. **Failure as a status string.** One error message for the whole call. Pixeltable: Each cell keeps its own error. `pxt errors` lists them.

Pipeline code, measured on its main branch (https://github.com/pixeltable/showcase-call-intelligence/blob/main/compare/WHY_PIXELTABLE.md): lines 668 (Celery) vs 392 (Pixeltable); files 14 (Celery) vs 2 (Pixeltable).

## Six habits the skill replaces

- **A framework for chunking and retrieval.** Wrong: `RecursiveCharacterTextSplitter + Chroma + RetrievalQA`. Right: `document_splitter`. Chunking is a view. Search is `.similarity()`. Tools are `pxt.tools()` and `invoke_tools()`.
- **pandas as the working store.** Wrong: `df['summary'] = df['text'].apply(call_openai)`. Right: `summary = chat_completions(...)`. The table is the store. `.collect().to_pandas()` is for export.
- **A for-loop calling a model.** Wrong: `for row in df.iterrows(): client.chat.completions.create(...)`. Right: `t.recompute_columns('summary', errors_only=True)`. The call is an assignment on the model. Retries rerun only the rows that failed.
- **A second vector database.** Wrong: `index.upsert(ids, vectors)`. Right: `__indexes__ = [pxt.EmbeddingIndex(...)]`. The index lives on the column. Search with `.similarity(string=query)`.
- **A while-loop agent.** Wrong: `while True: ...`. Right: `invoke_tools(tools, response)`. Insert a row. The model call, the tool calls, and the answer are columns that keep their state.
- **A model loaded on every row.** Wrong: `whisper.load_model('tiny.en')`. Right: `pxtf.whisper.transcribe(audio, model='tiny.en')`. The shipped wrappers cache the weights per process, so they load once.

And the small ones:

- `python app.py`: `pxt schema update`, then `pxt service update`
- Drop and recreate tables to reset: Edit `app.py`, then `pxt schema update`
- Chat history in Redis: A table
- A hard-coded `api_key=`: The environment or `config.toml`

The rest: https://github.com/pixeltable/pixeltable-skill/blob/main/skills/pixeltable-skill/references/anti-patterns.md

## Skill, backend, Cloud

### 1. Skill

The agent pulls Pixeltable in. One install teaches it tables, computed columns, indexes, and routes, and replaces the six habits above.

- Any agent: `npx skills add pixeltable/pixeltable-skill`
- Claude Code: add: `/plugin marketplace add pixeltable/pixeltable-skill`
- Claude Code: install: `/plugin install pixeltable@pixeltable-skill`
- Your agent’s setup: [Setup guides](#guides)
- What it teaches: [Agent Skill](https://www.pixeltable.com/agent-skill)

### 2. Backend

One file is the app’s state. Tables, computed columns, an embedding index, and routes live in `app.py`. Insert runs the models. Failures, versions, and recomputes stay in the tables, not in a chat scratchpad.

- Mark the project root: `pxt init`
- Create the tables: `pxt schema update app.py my_app -f`
- Serve HTTP: `pxt service update app.py my_app -f`
- Read failures: `pxt errors my_app/docs`
- The file, line by line: [Backend for AI agents](https://www.pixeltable.com/backend-for-ai-agents)

### 3. Cloud

The same file, hosted. Start free: `pxt new` makes one hosted database with no account and prints its URI; claim it within 48 hours. The next three commands apply the same file to that URI. Community is free; Pro is the paid step.

- Free database: `pxt new`
- Provision it: `pxt db update pxt://trial-x7k2:main -f`
- Create the tables: `pxt schema update app.py pxt://trial-x7k2:main -f`
- Serve HTTP: `pxt service update app.py pxt://trial-x7k2:main -f`
- What you get free: [Free database](https://www.pixeltable.com/new)
- Plans: [Pricing](https://www.pixeltable.com/pricing)

## Setup guides

- [Devin + Pixeltable](https://www.pixeltable.com/agents/devin) - Autonomous AI software engineer. Plans, codes, debugs, and deploys independently.
- [Claude Code + Pixeltable](https://www.pixeltable.com/agents/claude-code) - Agentic coding in your terminal. Understands your codebase, runs commands, and edits files.
- [Cursor + Pixeltable](https://www.pixeltable.com/agents/cursor) - The AI-first IDE. Agent mode edits across files, runs commands, and iterates on errors.
- [Codex + Pixeltable](https://www.pixeltable.com/agents/codex) - OpenAI's coding agent for the terminal and cloud. Reads and writes files, executes commands.
- [GitHub Copilot + Pixeltable](https://www.pixeltable.com/agents/github-copilot) - AI pair programmer with agent mode. The workspace agent understands your entire project.
- [Windsurf + Pixeltable](https://www.pixeltable.com/agents/windsurf) - The agentic IDE. Cascade flows through multi-step coding tasks.
- [Gemini CLI + Pixeltable](https://www.pixeltable.com/agents/gemini-cli) - Google's open-source terminal agent powered by Gemini.
- [OpenCode + Pixeltable](https://www.pixeltable.com/agents/opencode) - Open-source, provider-agnostic coding agent for the terminal.

## Further reading

- [The Unified Multimodal Backend Agents Build With](https://www.pixeltable.com/blog/unified-multimodal-backend-agents-build-with) (2026-09-16)
- [Making Multimodal More Lovable](https://www.pixeltable.com/blog/making-multimodal-more-lovable) (2026-08-28)
- [Where Does the Agent Live?](https://www.pixeltable.com/blog/where-does-the-agent-live) (2026-07-23)
- [Agents as Data: Why the Session Log Should Be Your System of Record](https://www.pixeltable.com/blog/agents-as-data-session-log-system-of-record) (2026-06-12)
- [Why Pixeltable is the Ultimate Agent Harness](https://www.pixeltable.com/blog/pixeltable-agent-harness) (2026-03-03)
- [Designing Software for LLMs as Customers: A Five-Stage Framework](https://www.pixeltable.com/blog/designing-software-for-llms-as-customers) (2026-05-16)

## Questions

### What does the Pixeltable skill change for a coding agent?

It teaches the agent to declare tables, computed columns, an embedding index, and routes in one `app.py`, and it replaces six habits: a retrieval framework, pandas as the store, model calls in a loop, a second vector database, a while-loop agent, and a model loaded on every row.

### Do I need an account to start?

No. Locally the agent runs `pxt init`, `pxt schema update`, and `pxt service update` with no account. For a hosted database, `pxt new` makes one with no account; claim it within 48 hours to keep it.

### Which coding agents does it work with?

Any agent that loads skills: `npx skills add pixeltable/pixeltable-skill` installs it for Claude Code, Cursor, Codex, GitHub Copilot, Windsurf, Gemini CLI, OpenCode, and Devin. Each has a setup guide on this page.

### What does Pixeltable Cloud cost?

Local Pixeltable is free and open source. On Cloud, Community is free and Pro is the paid plan; see the pricing page for what each includes.